﻿using System;
using System.Collections.Generic;

using System.Text;

namespace Rance.Battle
{
    class 巫师AI : AI
    {
        public override AIResult Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result;

            result = 招风术Excute(角色, 队伍状况, 技能mgt);
            if (result != null)
                return result;

            result = 护身术Excute(角色, 队伍状况, 技能mgt);
            if (result != null)
                return result;

            result = 全体护身术Excute(角色, 队伍状况, 技能mgt);
            if (result != null)
                return result;

            result = 豪雨术Excute(角色, 队伍状况, 技能mgt);
            if(result != null)
                return result;

            return 毒盅术Excute(角色, 队伍状况, 技能mgt);
        }

        protected AIResult 招风术Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            if (技能mgt.Has("招风术") && 角色.行动点 >= 2)
            {
                AIResult result = new AIResult();
                var 招风术 = 技能mgt.Get("招风术");
                result.Action = 招风术.Name;
                result.TargetList.Add(GetSoloTarget(ConvertSoloTarget(招风术.TargetList), 队伍状况));

                return result;
            }

            return null;
        }

        protected AIResult 护身术Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();
            if (技能mgt.Has("护身术") && 角色.行动点 >= 2)
            {
                var 准备队友List = 队伍状况.队伍.成员List.FindAll(r => r.是否准备 && !r.护盾);
                if (准备队友List.Count > 0)
                {
                    准备队友List.Sort((v1, v2) => v1.兵力.CompareTo(v2.兵力));
                    var 护身术 = 技能mgt.Get("护身术");
                    result.Action = 护身术.Name;
                    result.TargetList.Add(准备队友List[准备队友List.Count - 1]);

                    return result;
                }

                var 队友 = Get需要护盾的准备队友(角色, 队伍状况);
                if (队友 != null)
                {
                    if (队伍状况.战场.剩余回合数 > 6)
                    {
                        var 护身术 = 技能mgt.Get("护身术");
                        result.Action = 护身术.Name;
                        result.TargetList.Add(队友);

                        return result;
                    }
                }

                if (!角色.护盾)
                {
                    int 几率 = 0;
                    if (队伍状况.战场.剩余回合数 > 20)
                        几率 = 60;
                    else if (队伍状况.战场.剩余回合数 > 15)
                        几率 = 40;
                    else if (队伍状况.战场.剩余回合数 > 10)
                        几率 = 20;

                    bool hit = false;
                    if (几率 > 0)
                        hit = 队伍状况.战场.AI乱数表.Hit(几率);

                    if (hit)
                    {
                        var 护身术 = 技能mgt.Get("护身术");
                        result.Action = 护身术.Name;
                        result.TargetList.Add(角色);

                        return result;
                    }
                }
            }

            return null;
        }
        
        protected AIResult 全体护身术Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();
            if (技能mgt.Has("全体护身术"))
            {
                //剩余回合数 > 20 几率:30
                //剩余回合数 > 15 几率:20
                //剩余回合数 > 10 几率:10
                //每一个没有护盾的可行动的角色+10(不包含自己)
                //自己行动力 >= 4 几率:-60
                //自己行动力 >= 3 几率:-40
                //自己行动力 >= 2 几率:-10
                //自己行动力 = 1 几率:+10

                int 几率 = 0;
                if (队伍状况.战场.剩余回合数 > 20)
                    几率 = 30;
                else if (队伍状况.战场.剩余回合数 > 15)
                    几率 = 20;
                else if (队伍状况.战场.剩余回合数 > 10)
                    几率 = 10;

                foreach (var item in 队伍状况.队伍.成员List)
                {
                    if (item == 角色)
                        continue;

                    if (item.护盾)
                        continue;

                    if (item.是否完结)
                        continue;

                    几率 += 10;
                }

                switch (角色.行动点)
                {
                    case 1:
                        几率 += 10;
                        break;
                    case 2:
                        几率 -= 10;
                        break;
                    case 3:
                        几率 -= 40;
                        break;
                    default:
                        几率 -= 60;
                        break;
                }

                bool hit = false;
                if (几率 >= 100)
                    hit = true;
                else if (几率 <= 0)
                    hit = false;
                else
                    hit = 队伍状况.战场.AI乱数表.Hit(几率);

                if (hit)
                {
                    var 全体护身术 = 技能mgt.Get("全体护身术");
                    result.Action = 全体护身术.Name;
                    result.TargetList = 全体护身术.TargetList[0].List;

                    return result;
                }
            }
            return null;
        }

        protected AIResult 豪雨术Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            if (技能mgt.Has("豪雨术") && 角色.行动点 >= 2)
            {
                AIResult result = new AIResult();
                var 豪雨术 = 技能mgt.Get("豪雨术");
                result.Action = 豪雨术.Name;
                result.TargetList = 豪雨术.TargetList[0].List;

                return result;
            }

            return null;
        }

        protected AIResult 毒盅术Excute(角色 角色, 队伍状况 队伍状况, AI技能MGT 技能mgt)
        {
            AIResult result = new AIResult();
            var 毒盅术 = 技能mgt.Get("毒盅术");
            result.Action = 毒盅术.Name;
            result.TargetList = 毒盅术.TargetList[0].List;

            return result;
        }

        protected 角色 Get需要护盾的准备队友(角色 角色, 队伍状况 队伍状况)
        {
            队伍状况.队伍.成员List.Sort((v1, v2) => v1.实际智.CompareTo(v2.实际智));
            队伍状况.队伍.成员List.Reverse();

            foreach (var item in 队伍状况.队伍.成员List)
            {
                if (item == 角色)
                    continue;

                if (item.护盾)
                    continue;

                if (item.基础攻击技能 != null && item.基础攻击技能 is 准备技能)
                    return item;

                if (item.技能1 != null && item.技能1 is 准备技能)
                    return item;

                if (item.技能2 != null && item.技能2 is 准备技能)
                    return item;
            }

            return null;
        }

        protected 角色 GetSoloTarget(List<角色> targetList, 队伍状况 队伍状况)
        {
            targetList.Sort((v1, v2) => v1.兵力.CompareTo(v2.兵力));

            foreach (var item in targetList)
            {
                if (item.兵种.类型 == "巫师" ||
                    item.兵种.类型 == "军乐队" ||
                    item.兵种.类型 == "策士" ||
                    item.兵种.类型 == "军师")
                    continue;

                return item;
            }

            return targetList[0];
        }

        private static 巫师AI instance = new 巫师AI();
        public static 巫师AI GetInstance()
        {
            return instance;
        }
    }
}
